<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>

</body>

</html>
<script>
    //一.位置方法--indexOf()  lastIndexOf()返回要查找的项在数组中的索引位置，没找到的情况下返回-1。
    //两个参数：要查找的项和(可选的)表示查找起点位置的索引
    // var arr = ['apple', 'hello', 'hi', 'zhangsan', 'hi', 'orange'];
    // 1.indexOf() 方法从数组的开头开始向后查找。
    // console.log(arr.indexOf('hi')); //2
    // console.log(arr.indexOf('hehe')); //-1
    // console.log(arr.indexOf('hi', 3)); //4
    // 2.lastIndexOf() 方法则从数组的末尾开始向前查找。
    // console.log(arr.lastIndexOf('hi')); //4


    // 3.ES7里面的方法：includes():查找存在。
    // 查找一个数值是否在数组中，只能判断一些简单类型的数据，对于复杂类型的数据无法判断。该方法接受两个参数，分别是查询的数据和初始的查询索引值。
    // console.log(arr.includes('hi')); //true
    // console.log(arr.includes('hehe')); //false


    //数组去重。
    // var arr = [2, 5, 8, 6, 9, 8, 5, 2, 6, 9, ];
    // var newarr = [];
    //思路：
    //如果待去重的数组项在新的数组中不存在，添加到新数组。
    // for (var i = 0; i < arr.length; i++) {
    //     if (newarr.indexOf(arr[i]) === -1) { //满足条件，不存在
    //         newarr.push(arr[i]);
    //     }
    // }

    // for (var i = 0; i < arr.length; i++) {
    //     if (!newarr.includes(arr[i])) { //满足条件，不存在
    //         newarr.push(arr[i]);
    //     }
    // }
    // console.log(newarr);

    //二.迭代方法（不会改变原数组）- 自带遍历
    //两个参数：
    //第一个参数：要在每一项上运行的函数(函数当参数，回调函数)。
    //此函数会接收三个参数：数组项的值、该项在数组中的位置、数组对象本身。
    //第二个参数：（可选的）运行该函数的作用域对象（影响 this 的值）。


    //1.every()对数组中的每一项运行给定函数，如果该函数对每一项都返回 true ，则返回 true 。
    //适合统一或者一致的事情。
    // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
    // var result = arr.every(function(value, index, array) {
    //     //value:数组项的值  index:数组项的索引  array:数组本身
    //     return value > 0;
    // });
    // console.log(result);

    // var arr = ['hello', '123'];
    // var result = arr.every(function(v, i) {
    //     return typeof v === 'string';
    // });
    // console.log(result);


    //2.some()对数组中的每一项运行给定函数，如果该函数对任意一项返回 true ，则返回 true 。
    //类似于或运算符，满足一个即可。
    // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
    // var result = arr.some(function(value, index, array) {
    //     return value > 6;
    // });
    // console.log(result);


    //3.filter()对数组中的每一项运行给定函数，返回该函数结果为 true 的项组成的数组。
    // var arr = [1, 2, 3, 4, 1, 2, 3, 4];
    // var result = arr.filter(function(value, index, array) {
    //     // console.log(index); //每一个数组项的索引位置。
    //     // console.log(arr.indexOf(value)); //当前value在数组中第一次出现的位置。
    //     return array.indexOf(value) === index; //如果满足此条件，证明当前的value是第一次出现，绝对不会第二次出现。
    // });
    // console.log(result);


    // var arr1 = [1, 'hehe', 2, 'hello', 3, 'apple', 4, 1, 'orange', 2, 3, 4];
    // var result1 = arr1.filter(function(value, index, array) {
    //     return typeof value === 'string';
    // });
    // console.log(result1);



    //4.map() 对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。返回就是数组，不考虑true或者false。
    // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
    // var result = arr.map(function(value, index, array) {
    //     return value * 100;
    // });
    // console.log(result); //[100, 200, 300, 400, 500, 600, 700, 800, 900]


    //5.forEach() ：对数组中的每一项运行给定函数。这个方法没有返回值。
    // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
    // arr.forEach(function(value, index, array) {
    //     console.log(index + ':' + value + '--' + array);
    // });


    //三.归并方法---- reduce()  reduceRight()
    //迭代：为了一个结果，比如累加累减，统计个数...
    //迭代：而每一次迭代得到的结果会作为下一次迭代的初始值。
    //这两个方法都会迭代数组的所有项，然后构建一个最终返回的值。

    //reduce() 方法从数组的第一项开始，逐个遍历到最后。
    //两个参数：每一项上调用的函数和（可选的）作为归并的初始值。
    //1.使用一个参数,每一项上调用的函数
    //调用的函数又接收 4 个参数：前一个值、当前值、项的索引和数组对象。
    // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    // var result = arr.reduce(function(prev, curr, index, array) { //prev:前一个值  curr:当前值
    //     // console.log(prev); //第一次表示数组项的第一位，后面的每一次都是前面迭代的结果。
    //     // console.log(curr); //表示数组从第二次开始的值。  2, 3, 4, 5, 6, 7, 8, 9, 10
    //     console.log(prev + '|' + curr);
    //     return prev + curr;
    // });
    // console.log(result); //55


    //2.使用两个参数，每一项上调用的函数和（可选的）作为归并的初始值 - 重点
    // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    // var result = arr.reduce(function(prev, curr, index, array) {
    //     // console.log(prev); //第一次表示迭代的初始值，后面的每一次都是前面迭代的结果。
    //     // console.log(curr); //表示数组从第一次开始的值。 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
    //     console.log(prev + '|' + curr);
    //     return prev + curr;
    // }, 100); //100迭代的初始值。
    // console.log(result); //155

    //3.reduceRight() 方法从数组的最后一项开始，向前遍历到第一项。

    // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    // var result = arr.reduceRight(function(prev, curr, index, array) {
    //     // console.log(prev); //第一次表示迭代的初始值，后面的每一次都是前面迭代的结果。
    //     // console.log(curr); //表示数组从最后一次开始的值。 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
    //     console.log(prev + '|' + curr);
    //     return prev + curr;
    // }, 100); //100迭代的初始值。
    // console.log(result); //155

    //四.flat(num):ES6新增的扁平化的方法。
    // 扁平化：将一个多维数组转换成一位数组。
    // Infinity:无穷
    // var arr = [1, 2, [3, 4, [5, 6, [7, 8], 9], 10]]; //[1,2,3,4,5,6,7,8,9,10]
    // console.log(arr);
    // console.log(arr.flat(Infinity));
</script>